/**
 * API接口层 - 模拟服务端数据交互
 * 当前使用localStorage模拟，后续可直接替换为真实API调用
 */

// ==================== 模板相关API ====================

/**
 * 获取所有模板列表
 * @returns {Promise<Array>} 模板列表
 */
export const getTemplates = async () => {
  try {
    const templates = JSON.parse(localStorage.getItem('vform-templates') || '[]');
    // 按创建时间倒序排列
    return templates.sort((a, b) => new Date(b.createTime) - new Date(a.createTime));
  } catch (error) {
    console.error('获取模板列表失败:', error);
    throw error;
  }
};

/**
 * 根据ID获取模板详情
 * @param {string} templateId 模板ID
 * @returns {Promise<Object|null>} 模板详情
 */
export const getTemplateById = async (templateId) => {
  try {
    const templates = await getTemplates();
    return templates.find(template => template.id === templateId) || null;
  } catch (error) {
    console.error('获取模板详情失败:', error);
    throw error;
  }
};

/**
 * 创建新模板
 * @param {Object} templateData 模板数据
 * @returns {Promise<Object>} 创建的模板
 */
export const createTemplate = async (templateData) => {
  try {
    const templates = await getTemplates();
    const newTemplate = {
      id: Date.now().toString(),
      createTime: new Date().toISOString(),
      updateTime: new Date().toISOString(),
      ...templateData
    };
    
    templates.unshift(newTemplate); // 添加到开头
    localStorage.setItem('vform-templates', JSON.stringify(templates));
    return newTemplate;
  } catch (error) {
    console.error('创建模板失败:', error);
    throw error;
  }
};

/**
 * 更新模板
 * @param {string} templateId 模板ID
 * @param {Object} updateData 更新数据
 * @returns {Promise<Object>} 更新后的模板
 */
export const updateTemplate = async (templateId, updateData) => {
  try {
    const templates = await getTemplates();
    const templateIndex = templates.findIndex(template => template.id === templateId);
    
    if (templateIndex === -1) {
      throw new Error('模板不存在');
    }
    
    templates[templateIndex] = {
      ...templates[templateIndex],
      ...updateData,
      updateTime: new Date().toISOString()
    };
    
    localStorage.setItem('vform-templates', JSON.stringify(templates));
    return templates[templateIndex];
  } catch (error) {
    console.error('更新模板失败:', error);
    throw error;
  }
};

/**
 * 删除模板
 * @param {string} templateId 模板ID
 * @returns {Promise<boolean>} 删除结果
 */
export const deleteTemplate = async (templateId) => {
  try {
    const templates = await getTemplates();
    const filteredTemplates = templates.filter(template => template.id !== templateId);
    localStorage.setItem('vform-templates', JSON.stringify(filteredTemplates));
    return true;
  } catch (error) {
    console.error('删除模板失败:', error);
    throw error;
  }
};

/**
 * 批量删除模板
 * @returns {Promise<boolean>} 删除结果
 */
export const clearAllTemplates = async () => {
  try {
    localStorage.setItem('vform-templates', '[]');
    return true;
  } catch (error) {
    console.error('清空模板失败:', error);
    throw error;
  }
};

// ==================== 页面相关API ====================

/**
 * 获取所有页面列表
 * @returns {Promise<Array>} 页面列表
 */
export const getPages = async () => {
  try {
    const pages = JSON.parse(localStorage.getItem('vform-generated-pages') || '[]');
    // 按创建时间倒序排列
    return pages.sort((a, b) => new Date(b.createTime) - new Date(a.createTime));
  } catch (error) {
    console.error('获取页面列表失败:', error);
    throw error;
  }
};

/**
 * 根据ID获取页面详情
 * @param {string} pageId 页面ID
 * @returns {Promise<Object|null>} 页面详情
 */
export const getPageById = async (pageId) => {
  try {
    const pages = await getPages();
    return pages.find(page => page.id === pageId) || null;
  } catch (error) {
    console.error('获取页面详情失败:', error);
    throw error;
  }
};

/**
 * 创建新页面
 * @param {Object} pageData 页面数据
 * @returns {Promise<Object>} 创建的页面
 */
export const createPage = async (pageData) => {
  try {
    const pages = await getPages();
    const newPage = {
      id: Date.now().toString(),
      createTime: new Date().toISOString(),
      updateTime: new Date().toISOString(),
      ...pageData
    };
    
    pages.unshift(newPage); // 添加到开头
    localStorage.setItem('vform-generated-pages', JSON.stringify(pages));
    return newPage;
  } catch (error) {
    console.error('创建页面失败:', error);
    throw error;
  }
};

/**
 * 更新页面
 * @param {string} pageId 页面ID
 * @param {Object} updateData 更新数据
 * @returns {Promise<Object>} 更新后的页面
 */
export const updatePage = async (pageId, updateData) => {
  try {
    const pages = await getPages();
    const pageIndex = pages.findIndex(page => page.id === pageId);
    
    if (pageIndex === -1) {
      throw new Error('页面不存在');
    }
    
    pages[pageIndex] = {
      ...pages[pageIndex],
      ...updateData,
      updateTime: new Date().toISOString()
    };
    
    localStorage.setItem('vform-generated-pages', JSON.stringify(pages));
    return pages[pageIndex];
  } catch (error) {
    console.error('更新页面失败:', error);
    throw error;
  }
};

/**
 * 删除页面
 * @param {string} pageId 页面ID
 * @returns {Promise<boolean>} 删除结果
 */
export const deletePage = async (pageId) => {
  try {
    const pages = await getPages();
    const filteredPages = pages.filter(page => page.id !== pageId);
    localStorage.setItem('vform-generated-pages', JSON.stringify(filteredPages));
    return true;
  } catch (error) {
    console.error('删除页面失败:', error);
    throw error;
  }
};

/**
 * 批量删除页面
 * @returns {Promise<boolean>} 删除结果
 */
export const clearAllPages = async () => {
  try {
    localStorage.setItem('vform-generated-pages', '[]');
    return true;
  } catch (error) {
    console.error('清空页面失败:', error);
    throw error;
  }
};

// ==================== 用户相关API ====================

/**
 * 获取当前用户信息
 * @returns {Promise<Object|null>} 用户信息
 */
export const getCurrentUser = async () => {
  try {
    const userInfo = localStorage.getItem('current-user');
    return userInfo ? JSON.parse(userInfo) : null;
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return null;
  }
};

/**
 * 设置当前用户信息
 * @param {Object} userData 用户数据
 * @returns {Promise<Object>} 设置后的用户信息
 */
export const setCurrentUser = async (userData) => {
  try {
    const userInfo = {
      name: userData.name || userData.username || '系统用户',
      username: userData.username || userData.name || '系统用户',
      setTime: new Date().toISOString()
    };
    
    localStorage.setItem('current-user', JSON.stringify(userInfo));
    return userInfo;
  } catch (error) {
    console.error('设置用户信息失败:', error);
    throw error;
  }
};

// ==================== 统计数据API ====================

/**
 * 获取系统统计数据
 * @returns {Promise<Object>} 统计数据
 */
export const getSystemStats = async () => {
  try {
    const templates = await getTemplates();
    const pages = await getPages();
    
    // 计算活跃用户数
    const allCreators = new Set();
    templates.forEach(t => allCreators.add(t.creator));
    pages.forEach(p => allCreators.add(p.creator));
    
    // 计算今日新增
    const today = new Date().toDateString();
    const todayTemplates = templates.filter(t => {
      const createDate = new Date(t.createTime).toDateString();
      return createDate === today;
    });
    const todayPages = pages.filter(p => {
      const createDate = new Date(p.createTime).toDateString();
      return createDate === today;
    });
    
    return {
      templateCount: templates.length,
      pageCount: pages.length,
      userCount: allCreators.size,
      todayCount: todayTemplates.length + todayPages.length
    };
  } catch (error) {
    console.error('获取统计数据失败:', error);
    throw error;
  }
};

/**
 * 获取用户统计数据
 * @returns {Promise<Object>} 用户统计数据
 */
export const getUserStats = async () => {
  try {
    const currentUser = await getCurrentUser();
    const currentUserName = currentUser?.name || currentUser?.username || '系统用户';
    
    const templates = await getTemplates();
    const pages = await getPages();
    
    // 统计我的模板
    const myTemplates = templates.filter(t => t.creator === currentUserName);
    
    // 统计我的页面
    const myPages = pages.filter(p => p.creator === currentUserName);
    
    // 计算最近活跃时间
    const allUserItems = [...myTemplates, ...myPages];
    let lastActive = '未知';
    if (allUserItems.length > 0) {
      const latestItem = allUserItems.sort(
        (a, b) => new Date(b.createTime) - new Date(a.createTime)
      )[0];
      lastActive = new Date(latestItem.createTime).toLocaleDateString('zh-CN');
    }
    
    return {
      myTemplates: myTemplates.length,
      myPages: myPages.length,
      lastActive
    };
  } catch (error) {
    console.error('获取用户统计失败:', error);
    throw error;
  }
};

// ==================== 搜索相关API ====================

/**
 * 搜索模板
 * @param {string} keyword 搜索关键词
 * @returns {Promise<Array>} 搜索结果
 */
export const searchTemplates = async (keyword) => {
  try {
    const templates = await getTemplates();
    if (!keyword) return templates;
    
    return templates.filter(template => 
      template.templateName.toLowerCase().includes(keyword.toLowerCase()) ||
      template.creator.toLowerCase().includes(keyword.toLowerCase())
    );
  } catch (error) {
    console.error('搜索模板失败:', error);
    throw error;
  }
};

/**
 * 搜索页面
 * @param {string} keyword 搜索关键词
 * @returns {Promise<Array>} 搜索结果
 */
export const searchPages = async (keyword) => {
  try {
    const pages = await getPages();
    if (!keyword) return pages;
    
    return pages.filter(page => 
      page.pageName.toLowerCase().includes(keyword.toLowerCase()) ||
      page.creator.toLowerCase().includes(keyword.toLowerCase()) ||
      page.description.toLowerCase().includes(keyword.toLowerCase())
    );
  } catch (error) {
    console.error('搜索页面失败:', error);
    throw error;
  }
};

// ==================== 导出API ====================

/**
 * 导出所有数据
 * @returns {Promise<Object>} 导出的数据
 */
export const exportAllData = async () => {
  try {
    const templates = await getTemplates();
    const pages = await getPages();
    const currentUser = await getCurrentUser();
    
    return {
      templates,
      pages,
      currentUser,
      exportTime: new Date().toISOString()
    };
  } catch (error) {
    console.error('导出数据失败:', error);
    throw error;
  }
};

/**
 * 导入数据
 * @param {Object} data 导入的数据
 * @returns {Promise<boolean>} 导入结果
 */
export const importData = async (data) => {
  try {
    if (data.templates) {
      localStorage.setItem('vform-templates', JSON.stringify(data.templates));
    }
    if (data.pages) {
      localStorage.setItem('vform-generated-pages', JSON.stringify(data.pages));
    }
    if (data.currentUser) {
      localStorage.setItem('current-user', JSON.stringify(data.currentUser));
    }
    return true;
  } catch (error) {
    console.error('导入数据失败:', error);
    throw error;
  }
};
